import { isNumber } from '@src/util/type'
import i18n, { t } from '@src/locales'
import { isSafeNumber, formatDate, intlTimeFormat, shortcutIntlTemplate, IntlTempShortcutKey, formatAddress } from 'pub-bbx-utils'
import moment from 'moment'
import { fmtDist } from '@src/util/addressUtil';

import { useFormMultiLanguage } from '@hooks/useFormMultiLanguage'
const { internationalGray } = useFormMultiLanguage()
/** 格式化日期，支持毫秒 */
export function fmt_date(value){
  return formatDate(value, 'YYYY-MM-DD');
}

/** 格式化日期时间，支持毫秒 */
export function fmt_datetime(value, field) {
  const defaultFormat = 'YYYY-MM-DD HH:mm:ss'
  const dateType = field?.setting?.dateType || defaultFormat
  return formatDate(value, dateType);
}
/** 格式化日期时间,时分秒 */ 
export function fmt_hourMinuteSecond(value) {
  return formatDate(value,"HH:mm:ss");
}
// 转换计划开始时间和计划结束时间
export function fmt_textType(field) {
  if (field?.tableName && field?.tableName === 'project') {
    return t('common.form.tip.planTimeTip.tips1', {data1:t('common.form.tip.planTimeTip.project')})
  } else if (field?.tableName && field?.tableName === 'mission') {
    return t('common.form.tip.planTimeTip.tips1', {data1:t('common.form.tip.planTimeTip.mission')})
  } else if (field?.tableName && field?.tableName === 'task') {
    return t('common.form.tip.planTimeTip.tips1', {data1:t('common.form.tip.planTimeTip.task')})
  }
}

/** 格式化时间，返回到分钟 */
export function fmt_datehour(value){
  return formatDate(value, 'YYYY-MM-DD HH:mm');
}

/** 取日期字符串的前16位 */
export function fmt_date_16(value){
  let reg = /^[1-9]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])\s{1}(20|21|22|23|[0-1]\d):[0-5]\d:[0-5]\d$/;
  return reg.test(value) ? value.slice(0, 16) : value;
}
/**
 * 格式化时间，返回本地化的时间字符串
 * @param {string|number|Date} time 时间
 * @returns {string} 本地化的时间字符串
 */
export function fmt_short_time(time){
  if(!time || !moment(time).isValid()) return ''
  const options = {...shortcutIntlTemplate[IntlTempShortcutKey.hour12]}; // 12小时制
  if(!moment().isSame(time, 'day')) {
    // 不是当天的显示 月、日
    options['month'] = 'short';
    options['day'] = 'numeric';
  }
  if(!moment().isSame(time, 'year')){
    // 不是当年的追加显示 年
    options['year'] = 'numeric';
  }
  return intlTimeFormat(time, options, i18n.locale);
}

/** 数字保留两位小数 */
export function fmt_number_fixed2(value, currencyType){
  // 不是数字 或 是NaN 或 是无穷，直接返回原值
  if(!isSafeNumber(value)) return value;
  let totalValue = value.toFixed(2)
  if(internationalGray && currencyType) return `${totalValue} ${currencyType}`
  return totalValue;
}

/** 货币金额的处理，如果是空的话展示-，不是空直接展示- */
export function fmt_currency_fixed2(value, currency='CNY'){
  // 不是数字 或 是NaN 或 是无穷，直接返回原值
  if(!isSafeNumber(value)) return internationalGray ? '-' : value;
  let price = value.toFixed(2);
  return internationalGray ? `${price} ${currency}` : price;
}

/** 数字取整*/
export function fmt_number_int(value){
  if(!isSafeNumber(value)) return value;
  return Math.floor(value);
}

/** 格式化地址 */
export function fmt_address(value){
  // 这里null需要特判，因为 typeof null == 'object'
  if(null == value || typeof value != 'object') return value;
  const country = value.adCountry || value.country || '';
  let province = value.adProvince || value.province || '';
  let city = value.adCity || value.city || '';
  let dist = value.adDist || value.dist || '';
  let street = value.township || value.adStreet  || value.street || '';
  let address = value.adAddress || value.address || '';
  const arr =[country,province,city,dist,street,address].filter(item => item)
  
  return arr.join('-');
}

// 格式化工单客户地址
export function getCustomerArrdess(task) {
  return {
    adCountry: task?.taddress?.country || '',	
    adProvince: task?.taddress?.province || '',
    adCity: task?.taddress?.city || '',
    adDist: task?.taddress?.dist || ''
  }
}
/** 格式化区域 */
export function fmt_dist(value, separator = '-'){
  return fmtDist(value, separator)
}

// 工单状态
export function fmt_state(value) {
  const stateMap = {
    created: t('common.task.type.created'),
    allocated: t('common.task.type.allocated'),
    taskPool: t('common.task.type.taskPool'),
    accepted: t('common.task.type.accepted'),
    processing: t('common.task.type.processing'),
    convert2Task: t('common.task.type.convert2Task'),
    finished: t('common.task.type.finished'),
    refused: t('common.task.type.refused'),
    costed: t('common.task.type.costed'),
    closed: t('common.task.type.closed'),
    offed: t('common.task.type.offed'),
  }
  return stateMap[value] || ''
}

export function fmt_h_m_s(sec = 0) {
  const HOUR_SEC = 60 * 60;
  const MIN_SEC = 60;

  let hour = sec / HOUR_SEC >> 0;
  sec = sec % HOUR_SEC;

  let min = sec / MIN_SEC >> 0;
  sec = sec % MIN_SEC;

  let temp = '';

  if(hour > 0) temp += `${hour}${t('common.time.hour')}`;
  if(min > 0) temp += `${min}${t('common.time.minute')}`;
  if(sec > 0) temp += `${sec}${t('common.time.second')}`;

  return temp ? temp : '--';
}

/**
 * @description 格式化数据 (值不存在返回 默认返回0)
 */
export function fmt_number(value, defaultValue = 0) {
  if (value == undefined || value == null) {
    return defaultValue
  }
  
  if (isNaN(value)) {
    console.warn(`Caused: ${value} is NaN`)
    return defaultValue
  }
  
  const IsErrorType = typeof value == 'string' || typeof value == 'number'
  // 非数字类型 或 字符串
  if (!IsErrorType) {
    console.warn(`Caused: ${value} is not string type`)
    return defaultValue
  }
  
  let number = Number(value)
  // 格式化的数字是NaN
  if (isNaN(number)) {
    console.warn(`Caused: Number(${number}) is NaN`)
    return defaultValue
  }
  
  // 非安全数值
  if(!isSafeNumber(number)) {
    console.warn(`Caused: ${number} is not a safeNumber`)
    return number
  }
  
  return number
}

export function fmt_number_limit(value, limit) {
  let isValueNumberType = isNumber(value)
  let isLimitNumberType = isNumber(limit)
  if (!isValueNumberType || !isLimitNumberType) return value
  
  return limit > value ? `${limit - 1}+` : value
  
}

/** 
 * @description 格式化显示文字
*/
export function fmt_display_text(value, text) {
  return value ? `${value}${text || ''}` : '--'
}

/** 
 * @description 格式化显示数组
 * @param {Number} value 值
 * @param {Number} num 规定小数的位数，是 0 ~ 20 之间的值，包括 0 和 20，有些实现可以支持更大的数值范围
*/
export function fmt_number_to_fixed(value, num) {
  if (!isNumber(value)) return value
  
  return value.toFixed(num)
}


/**
 * @description 格式化秒到小时字符串
 * @param {Number} seconds 秒
 * @return {String} 格式化的字符串
 */
export function fmt_seconds_to_hour_str(seconds) {
  if (!isNumber(seconds)) return seconds
  
  let hourSec = 60 * 60
  let minuteSec = 60
  let hh = Math.floor(seconds / hourSec)
  let mm = Math.round((seconds % hourSec) / minuteSec) || 1
  
  return `${hh}${t('common.time.hour')}${mm}${t('common.time.minute')}`
}

const fmt = {
  formatDate,
  fmt_date,
  fmt_datetime,
  fmt_date_16,
  fmt_number_fixed2,
  fmt_number_int,
  fmt_address,
  fmt_dist,
  fmt_datehour,
  fmt_state,
  fmt_short_time,
  fmt_h_m_s,
  fmt_display_text,
  fmt_seconds_to_hour_str,
  fmt_currency_fixed2,
  fmt_textType,
  fmt_hourMinuteSecond
}

export default fmt;